home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Development Tools & Languages / Dylan Related / Marlais / Marlais 0.5.9-portable sources / gc / malloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-15  |  16.1 KB  |  632 lines  |  [TEXT/ttxt]
  1. /* 
  2.  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
  3.  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
  4.  *
  5.  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
  6.  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
  7.  *
  8.  * Permission is hereby granted to use or copy this program
  9.  * for any purpose,  provided the above notices are retained on all copies.
  10.  * Permission to modify the code and to distribute modified code is granted,
  11.  * provided the above notices are retained, and a notice that the code was
  12.  * modified is included with the above copyright notice.
  13.  */
  14. /* Boehm, February 10, 1995 12:55 pm PST */
  15.  
  16. #include <stdio.h>
  17. #include "gc_priv.h"
  18.  
  19. extern ptr_t GC_clear_stack();    /* in misc.c, behaves like identity */
  20. void GC_extend_size_map();    /* in misc.c. */
  21.  
  22. /* Allocate reclaim list for kind:    */
  23. /* Return TRUE on success        */
  24. bool GC_alloc_reclaim_list(kind)
  25. register struct obj_kind * kind;
  26. {
  27.     struct hblk ** result = (struct hblk **)
  28.             GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
  29.     if (result == 0) return(FALSE);
  30.     BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
  31.     kind -> ok_reclaim_list = result;
  32.     return(TRUE);
  33. }
  34.  
  35. /* allocate lb bytes for an object of kind.    */
  36. /* Should not be used to directly to allocate    */
  37. /* objects such as STUBBORN objects that    */
  38. /* require special handling on allocation.    */
  39. /* First a version that assumes we already    */
  40. /* hold lock:                    */
  41. ptr_t GC_generic_malloc_inner(lb, k)
  42. register word lb;
  43. register int k;
  44. {
  45. register word lw;
  46. register ptr_t op;
  47. register ptr_t *opp;
  48.  
  49.     if( SMALL_OBJ(lb) ) {
  50.         register struct obj_kind * kind = GC_obj_kinds + k;
  51. #       ifdef MERGE_SIZES
  52.       lw = GC_size_map[lb];
  53. #    else
  54.       lw = ALIGNED_WORDS(lb);
  55.       if (lw == 0) lw = 1;
  56. #       endif
  57.     opp = &(kind -> ok_freelist[lw]);
  58.         if( (op = *opp) == 0 ) {
  59. #        ifdef MERGE_SIZES
  60.           if (GC_size_map[lb] == 0) {
  61.             if (!GC_is_initialized)  GC_init_inner();
  62.             if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
  63.             return(GC_generic_malloc_inner(lb, k));
  64.           }
  65. #        else
  66.           if (!GC_is_initialized) {
  67.             GC_init_inner();
  68.             return(GC_generic_malloc_inner(lb, k));
  69.           }
  70. #        endif
  71.         if (kind -> ok_reclaim_list == 0) {
  72.             if (!GC_alloc_reclaim_list(kind)) goto out;
  73.         }
  74.         op = GC_allocobj(lw, k);
  75.         if (op == 0) goto out;
  76.         }
  77.         /* Here everything is in a consistent state.    */
  78.         /* We assume the following assignment is    */
  79.         /* atomic.  If we get aborted            */
  80.         /* after the assignment, we lose an object,    */
  81.         /* but that's benign.                */
  82.         /* Volatile declarations may need to be added    */
  83.         /* to prevent the compiler from breaking things.*/
  84.         *opp = obj_link(op);
  85.         obj_link(op) = 0;
  86.     } else {
  87.     register struct hblk * h;
  88.     register word n_blocks = divHBLKSZ(ADD_SLOP(lb)
  89.                        + HDR_BYTES + HBLKSIZE-1);
  90.     
  91.     if (!GC_is_initialized) GC_init_inner();
  92.     /* Do our share of marking work */
  93.           if(GC_incremental && !GC_dont_gc)
  94.         GC_collect_a_little_inner((int)n_blocks);
  95.     lw = ROUNDED_UP_WORDS(lb);
  96.     while ((h = GC_allochblk(lw, k, 0)) == 0
  97.         && GC_collect_or_expand(n_blocks));
  98.     if (h == 0) {
  99.         op = 0;
  100.     } else {
  101.         op = (ptr_t) (h -> hb_body);
  102.         GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
  103.     }
  104.     }
  105.     GC_words_allocd += lw;
  106.     
  107. out:
  108.     return((ptr_t)op);
  109. }
  110.  
  111. /* Allocate a composite object of size n bytes.  The caller guarantees    */
  112. /* that pointers past the first page are not relevant.  Caller holds    */
  113. /* allocation lock.                            */
  114. ptr_t GC_generic_malloc_inner_ignore_off_page(lb, k)
  115. register size_t lb;
  116. register int k;
  117. {
  118. # ifdef ALL_INTERIOR_POINTERS
  119.     register struct hblk * h;
  120.     register word n_blocks;
  121.     register word lw;
  122.     register ptr_t op;
  123.  
  124.     if (lb <= HBLKSIZE)
  125.         return(GC_generic_malloc_inner((word)lb, k));
  126.     n_blocks = divHBLKSZ(ADD_SLOP(lb) + HDR_BYTES + HBLKSIZE-1);
  127.     if (!GC_is_initialized) GC_init_inner();
  128.     /* Do our share of marking work */
  129.     if(GC_incremental && !GC_dont_gc)
  130.     GC_collect_a_little_inner((int)n_blocks);
  131.     lw = ROUNDED_UP_WORDS(lb);
  132.     while ((h = GC_allochblk(lw, k, IGNORE_OFF_PAGE)) == 0
  133.        && GC_collect_or_expand(n_blocks));
  134.     if (h == 0) {
  135.     op = 0;
  136.     } else {
  137.     op = (ptr_t) (h -> hb_body);
  138.     GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
  139.     }
  140.     GC_words_allocd += lw;
  141.     return((ptr_t)op);
  142. # else
  143.     return(GC_generic_malloc_inner((word)lb, k));
  144. # endif
  145. }
  146.  
  147. ptr_t GC_generic_malloc_ignore_off_page(lb, k)
  148. register size_t lb;
  149. register int k;
  150. {
  151.     register ptr_t result;
  152.     DCL_LOCK_STATE;
  153.     
  154.     GC_invoke_finalizers();
  155.     DISABLE_SIGNALS();
  156.     LOCK();
  157.     result = GC_generic_malloc_inner_ignore_off_page(lb,k);
  158.     UNLOCK();
  159.     ENABLE_SIGNALS();
  160.     return(result);
  161. }
  162.  
  163. # if defined(__STDC__) || defined(__cplusplus)
  164.   void * GC_malloc_ignore_off_page(size_t lb)
  165. # else
  166.   char * GC_malloc_ignore_off_page(lb)
  167.   register size_t lb;
  168. # endif
  169. {
  170.     return((extern_ptr_t)GC_generic_malloc_ignore_off_page(lb, NORMAL));
  171. }
  172.  
  173. # if defined(__STDC__) || defined(__cplusplus)
  174.   void * GC_malloc_atomic_ignore_off_page(size_t lb)
  175. # else
  176.   char * GC_malloc_atomic_ignore_off_page(lb)
  177.   register size_t lb;
  178. # endif
  179. {
  180.     return((extern_ptr_t)GC_generic_malloc_ignore_off_page(lb, PTRFREE));
  181. }
  182.  
  183. ptr_t GC_generic_malloc(lb, k)
  184. register word lb;
  185. register int k;
  186. {
  187.     ptr_t result;
  188.     DCL_LOCK_STATE;
  189.  
  190.     GC_invoke_finalizers();
  191.     DISABLE_SIGNALS();
  192.     LOCK();
  193.     result = GC_generic_malloc_inner(lb, k);
  194.     UNLOCK();
  195.     ENABLE_SIGNALS();
  196.     return(result);
  197. }   
  198.  
  199.  
  200. /* Analogous to the above, but assumes a small object size, and     */
  201. /* bypasses MERGE_SIZES mechanism.  Used by gc_inline.h.        */
  202. ptr_t GC_generic_malloc_words_small(lw, k)
  203. register word lw;
  204. register int k;
  205. {
  206. register ptr_t op;
  207. register ptr_t *opp;
  208. register struct obj_kind * kind = GC_obj_kinds + k;
  209. DCL_LOCK_STATE;
  210.  
  211.     GC_invoke_finalizers();
  212.     DISABLE_SIGNALS();
  213.     LOCK();
  214.     opp = &(kind -> ok_freelist[lw]);
  215.     if( (op = *opp) == 0 ) {
  216.         if (!GC_is_initialized) {
  217.             GC_init_inner();
  218.         }
  219.     if (kind -> ok_reclaim_list == 0) {
  220.         if (!GC_alloc_reclaim_list(kind)) goto out;
  221.     }
  222.     op = GC_clear_stack(GC_allocobj(lw, k));
  223.     if (op == 0) goto out;
  224.     }
  225.     *opp = obj_link(op);
  226.     obj_link(op) = 0;
  227.     GC_words_allocd += lw;
  228.     
  229. out:
  230.     UNLOCK();
  231.     ENABLE_SIGNALS();
  232.     return((ptr_t)op);
  233. }
  234.  
  235. #if defined(THREADS) && !defined(SRC_M3)
  236. /* Return a list of 1 or more objects of the indicated size, linked    */
  237. /* through the first word in the object.  This has the advantage that    */
  238. /* it acquires the allocation lock only once, and may greatly reduce    */
  239. /* time wasted contending for the allocation lock.  Typical usage would */
  240. /* be in a thread that requires many items of the same size.  It would    */
  241. /* keep its own free list in thread-local storage, and call        */
  242. /* GC_malloc_many or friends to replenish it.  (We do not round up    */
  243. /* object sizes, since a call indicates the intention to consume many    */
  244. /* objects of exactly this size.)                    */
  245. /* Note that the client should usually clear the link field.        */
  246. ptr_t GC_generic_malloc_many(lb, k)
  247. register word lb;
  248. register int k;
  249. {
  250. ptr_t op;
  251. register ptr_t p;
  252. ptr_t *opp;
  253. word lw;
  254. register word my_words_allocd;
  255. DCL_LOCK_STATE;
  256.  
  257.     if (!SMALL_OBJ(lb)) {
  258.         op = GC_generic_malloc(lb, k);
  259.         obj_link(op) = 0;
  260.         return(op);
  261.     }
  262.     lw = ALIGNED_WORDS(lb);
  263.     GC_invoke_finalizers();
  264.     DISABLE_SIGNALS();
  265.     LOCK();
  266.     opp = &(GC_obj_kinds[k].ok_freelist[lw]);
  267.     if( (op = *opp) == 0 ) {
  268.         if (!GC_is_initialized) {
  269.             GC_init_inner();
  270.         }
  271.     op = GC_clear_stack(GC_allocobj(lw, k));
  272.     if (op == 0) goto out;
  273.     }
  274.     *opp = 0;
  275.     my_words_allocd = 0;
  276.     for (p = op; p != 0; p = obj_link(p)) {
  277.         my_words_allocd += lw;
  278.         if (my_words_allocd >= BODY_SZ) {
  279.             *opp = obj_link(p);
  280.             obj_link(p) = 0;
  281.             break;
  282.         }
  283.     }
  284.     GC_words_allocd += my_words_allocd;
  285.     
  286. out:
  287.     UNLOCK();
  288.     ENABLE_SIGNALS();
  289.     return(op);
  290.  
  291. }
  292.  
  293. void * GC_malloc_many(size_t lb)
  294. {
  295.     return(GC_generic_malloc_many(lb, NORMAL));
  296. }
  297.  
  298. /* Note that the "atomic" version of this would be unsafe, since the    */
  299. /* links would not be seen by the collector.                */
  300. # endif
  301.  
  302. #define GENERAL_MALLOC(lb,k) \
  303.     (extern_ptr_t)GC_clear_stack(GC_generic_malloc((word)lb, k))
  304. /* We make the GC_clear_stack_call a tail call, hoping to get more of    */
  305. /* the stack.                                */
  306.  
  307. /* Allocate lb bytes of atomic (pointerfree) data */
  308. # ifdef __STDC__
  309.     extern_ptr_t GC_malloc_atomic(size_t lb)
  310. # else
  311.     extern_ptr_t GC_malloc_atomic(lb)
  312.     size_t lb;
  313. # endif
  314. {
  315. register ptr_t op;
  316. register ptr_t * opp;
  317. register word lw;
  318. DCL_LOCK_STATE;
  319.  
  320.     if( SMALL_OBJ(lb) ) {
  321. #       ifdef MERGE_SIZES
  322.       lw = GC_size_map[lb];
  323. #    else
  324.       lw = ALIGNED_WORDS(lb);
  325. #       endif
  326.     opp = &(GC_aobjfreelist[lw]);
  327.     FASTLOCK();
  328.         if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
  329.             FASTUNLOCK();
  330.             return(GENERAL_MALLOC((word)lb, PTRFREE));
  331.         }
  332.         /* See above comment on signals.    */
  333.         *opp = obj_link(op);
  334.         GC_words_allocd += lw;
  335.         FASTUNLOCK();
  336.         return((extern_ptr_t) op);
  337.    } else {
  338.        return(GENERAL_MALLOC((word)lb, PTRFREE));
  339.    }
  340. }
  341.  
  342. /* Allocate lb bytes of composite (pointerful) data */
  343. # ifdef __STDC__
  344.     extern_ptr_t GC_malloc(size_t lb)
  345. # else
  346.     extern_ptr_t GC_malloc(lb)
  347.     size_t lb;
  348. # endif
  349. {
  350. register ptr_t op;
  351. register ptr_t *opp;
  352. register word lw;
  353. DCL_LOCK_STATE;
  354.  
  355.     if( SMALL_OBJ(lb) ) {
  356. #       ifdef MERGE_SIZES
  357.       lw = GC_size_map[lb];
  358. #    else
  359.       lw = ALIGNED_WORDS(lb);
  360. #       endif
  361.     opp = &(GC_objfreelist[lw]);
  362.     FASTLOCK();
  363.         if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
  364.             FASTUNLOCK();
  365.             return(GENERAL_MALLOC((word)lb, NORMAL));
  366.         }
  367.         /* See above comment on signals.    */
  368.         *opp = obj_link(op);
  369.         obj_link(op) = 0;
  370.         GC_words_allocd += lw;
  371.         FASTUNLOCK();
  372.         return((extern_ptr_t) op);
  373.    } else {
  374.        return(GENERAL_MALLOC((word)lb, NORMAL));
  375.    }
  376. }
  377.  
  378. # ifdef REDIRECT_MALLOC
  379. # ifdef __STDC__
  380.     extern_ptr_t malloc(size_t lb)
  381. # else
  382.     extern_ptr_t malloc(lb)
  383.     size_t lb;
  384. # endif
  385.   {
  386.     /* It might help to manually inline the GC_malloc call here.    */
  387.     /* But any decent compiler should reduce the extra procedure call    */
  388.     /* to at most a jump instruction in this case.            */
  389.     return(REDIRECT_MALLOC(lb));
  390.   }
  391.  
  392. # ifdef __STDC__
  393.     extern_ptr_t calloc(size_t n, size_t lb)
  394. # else
  395.     extern_ptr_t calloc(n, lb)
  396.     size_t n, lb;
  397. # endif
  398.   {
  399.     return(REDIRECT_MALLOC(n*lb));
  400.   }
  401. # endif /* REDIRECT_MALLOC */
  402.  
  403. /* Allocate lb bytes of pointerful, traced, but not collectable data */
  404. # ifdef __STDC__
  405.     extern_ptr_t GC_malloc_uncollectable(size_t lb)
  406. # else
  407.     extern_ptr_t GC_malloc_uncollectable(lb)
  408.     size_t lb;
  409. # endif
  410. {
  411. register ptr_t op;
  412. register ptr_t *opp;
  413. register word lw;
  414. DCL_LOCK_STATE;
  415.  
  416.     if( SMALL_OBJ(lb) ) {
  417. #       ifdef MERGE_SIZES
  418. #      ifdef ADD_BYTE_AT_END
  419.         lb--; /* We don't need the extra byte, since this won't be    */
  420.               /* collected anyway.                    */
  421. #      endif
  422.       lw = GC_size_map[lb];
  423. #    else
  424.       lw = ALIGNED_WORDS(lb);
  425. #       endif
  426.     opp = &(GC_uobjfreelist[lw]);
  427.     FASTLOCK();
  428.         if( FASTLOCK_SUCCEEDED() && (op = *opp) != 0 ) {
  429.             /* See above comment on signals.    */
  430.             *opp = obj_link(op);
  431.             obj_link(op) = 0;
  432.             GC_words_allocd += lw;
  433.             GC_set_mark_bit(op);
  434.             GC_non_gc_bytes += WORDS_TO_BYTES(lw);
  435.             FASTUNLOCK();
  436.             return((extern_ptr_t) op);
  437.         }
  438.         FASTUNLOCK();
  439.         op = (ptr_t)GC_generic_malloc((word)lb, UNCOLLECTABLE);
  440.     } else {
  441.     op = (ptr_t)GC_generic_malloc((word)lb, UNCOLLECTABLE);
  442.     }
  443.     /* We don't need the lock here, since we have an undisguised     */
  444.     /* pointer.  We do need to hold the lock while we adjust        */
  445.     /* mark bits.                            */
  446.     {
  447.     register struct hblk * h;
  448.     
  449.     h = HBLKPTR(op);
  450.     lw = HDR(h) -> hb_sz;
  451.     
  452.     DISABLE_SIGNALS();
  453.     LOCK();
  454.     GC_set_mark_bit(op);
  455.     GC_non_gc_bytes += WORDS_TO_BYTES(lw);
  456.     UNLOCK();
  457.     ENABLE_SIGNALS();
  458.     return((extern_ptr_t) op);
  459.     }
  460. }
  461.  
  462. extern_ptr_t GC_generic_or_special_malloc(lb,knd)
  463. word lb;
  464. int knd;
  465. {
  466.     switch(knd) {
  467. #     ifdef STUBBORN_ALLOC
  468.     case STUBBORN:
  469.         return(GC_malloc_stubborn((size_t)lb));
  470. #     endif
  471.     case PTRFREE:
  472.         return(GC_malloc_atomic((size_t)lb));
  473.     case NORMAL:
  474.         return(GC_malloc((size_t)lb));
  475.     case UNCOLLECTABLE:
  476.         return(GC_malloc_uncollectable((size_t)lb));
  477.     default:
  478.         return(GC_generic_malloc(lb,knd));
  479.     }
  480. }
  481.  
  482.  
  483. /* Change the size of the block pointed to by p to contain at least   */
  484. /* lb bytes.  The object may be (and quite likely will be) moved.     */
  485. /* The kind (e.g. atomic) is the same as that of the old.          */
  486. /* Shrinking of large blocks is not implemented well.                 */
  487. # ifdef __STDC__
  488.     extern_ptr_t GC_realloc(extern_ptr_t p, size_t lb)
  489. # else
  490.     extern_ptr_t GC_realloc(p,lb)
  491.     extern_ptr_t p;
  492.     size_t lb;
  493. # endif
  494. {
  495. register struct hblk * h;
  496. register hdr * hhdr;
  497. register word sz;     /* Current size in bytes    */
  498. register word orig_sz;     /* Original sz in bytes    */
  499. int obj_kind;
  500.  
  501.     if (p == 0) return(GC_malloc(lb));    /* Required by ANSI */
  502.     h = HBLKPTR(p);
  503.     hhdr = HDR(h);
  504.     sz = hhdr -> hb_sz;
  505.     obj_kind = hhdr -> hb_obj_kind;
  506.     sz = WORDS_TO_BYTES(sz);
  507.     orig_sz = sz;
  508.  
  509.     if (sz > WORDS_TO_BYTES(MAXOBJSZ)) {
  510.     /* Round it up to the next whole heap block */
  511.       
  512.       sz = (sz+HDR_BYTES+HBLKSIZE-1)
  513.         & (~HBLKMASK);
  514.       sz -= HDR_BYTES;
  515.       hhdr -> hb_sz = BYTES_TO_WORDS(sz);
  516.       if (obj_kind == UNCOLLECTABLE) GC_non_gc_bytes += (sz - orig_sz);
  517.       /* Extra area is already cleared by allochblk. */
  518.     }
  519.     if (ADD_SLOP(lb) <= sz) {
  520.     if (lb >= (sz >> 1)) {
  521. #        ifdef STUBBORN_ALLOC
  522.             if (obj_kind == STUBBORN) GC_change_stubborn(p);
  523. #        endif
  524.         if (orig_sz > lb) {
  525.           /* Clear unneeded part of object to avoid bogus pointer */
  526.           /* tracing.                          */
  527.           /* Safe for stubborn objects.                  */
  528.             BZERO(((ptr_t)p) + lb, orig_sz - lb);
  529.         }
  530.         return(p);
  531.     } else {
  532.         /* shrink */
  533.           extern_ptr_t result =
  534.                   GC_generic_or_special_malloc((word)lb, obj_kind);
  535.  
  536.           if (result == 0) return(0);
  537.               /* Could also return original object.  But this     */
  538.               /* gives the client warning of imminent disaster.    */
  539.           BCOPY(p, result, lb);
  540.           GC_free(p);
  541.           return(result);
  542.     }
  543.     } else {
  544.     /* grow */
  545.       extern_ptr_t result =
  546.           GC_generic_or_special_malloc((word)lb, obj_kind);
  547.  
  548.       if (result == 0) return(0);
  549.       BCOPY(p, result, sz);
  550.       GC_free(p);
  551.       return(result);
  552.     }
  553. }
  554.  
  555. # ifdef REDIRECT_MALLOC
  556. # ifdef __STDC__
  557.     extern_ptr_t realloc(extern_ptr_t p, size_t lb)
  558. # else
  559.     extern_ptr_t realloc(p,lb)
  560.     extern_ptr_t p;
  561.     size_t lb;
  562. # endif
  563.   {
  564.     return(GC_realloc(p, lb));
  565.   }
  566. # endif /* REDIRECT_MALLOC */
  567.  
  568. /* Explicitly deallocate an object p.                */
  569. # ifdef __STDC__
  570.     void GC_free(extern_ptr_t p)
  571. # else
  572.     void GC_free(p)
  573.     extern_ptr_t p;
  574. # endif
  575. {
  576.     register struct hblk *h;
  577.     register hdr *hhdr;
  578.     register signed_word sz;
  579.     register ptr_t * flh;
  580.     register int knd;
  581.     register struct obj_kind * ok;
  582.     DCL_LOCK_STATE;
  583.  
  584.     if (p == 0) return;
  585.         /* Required by ANSI.  It's not my fault ...    */
  586.     h = HBLKPTR(p);
  587.     hhdr = HDR(h);
  588.     knd = hhdr -> hb_obj_kind;
  589.     sz = hhdr -> hb_sz;
  590.     ok = &GC_obj_kinds[knd];
  591.     if (sz <= MAXOBJSZ) {
  592. #    ifdef THREADS
  593.         DISABLE_SIGNALS();
  594.         LOCK();
  595. #    endif
  596.     GC_mem_freed += sz;
  597.     /* A signal here can make GC_mem_freed and GC_non_gc_bytes    */
  598.     /* inconsistent.  We claim this is benign.            */
  599.     if (knd == UNCOLLECTABLE) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
  600.     if (ok -> ok_init) {
  601.         BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
  602.     }
  603.     flh = &(ok -> ok_freelist[sz]);
  604.     obj_link(p) = *flh;
  605.     *flh = (ptr_t)p;
  606. #    ifdef THREADS
  607.         UNLOCK();
  608.         ENABLE_SIGNALS();
  609. #    endif
  610.     } else {
  611.         DISABLE_SIGNALS();
  612.         LOCK();
  613.         GC_mem_freed += sz;
  614.     if (knd == UNCOLLECTABLE) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
  615.         GC_freehblk(h);
  616.         UNLOCK();
  617.         ENABLE_SIGNALS();
  618.     }
  619. }
  620.  
  621. # ifdef REDIRECT_MALLOC
  622. #   ifdef __STDC__
  623.       void free(extern_ptr_t p)
  624. #   else
  625.       void free(p)
  626.       extern_ptr_t p;
  627. #   endif
  628.   {
  629.       GC_free(p);
  630.   }
  631. # endif  /* REDIRECT_MALLOC */
  632.